home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / fish / 676-700 / 681 / term / source.lha / FastMacros.c < prev    next >
C/C++ Source or Header  |  1992-05-09  |  10KB  |  527 lines
  1. /*
  2. **    $Id: FastMacros.c,v 1.2 92/04/06 20:10:01 olsen Sta Locker: olsen $
  3. **    $Revision: 1.2 $
  4. **    $Date: 92/04/06 20:10:01 $
  5. **
  6. **    Fast! macros support routines
  7. **
  8. **    Copyright © 1990-1992 by Olaf `Olsen' Barthel & MXM
  9. **        All Rights Reserved
  10. */
  11.  
  12. #include "termGlobal.h"
  13.  
  14. STATIC WORD         Left = -1,Top = -1,Height = -1;
  15. STATIC struct Gadget    *GadgetList = NULL;
  16. STATIC struct IBox     Dims = { -1,-1,-1,-1 };
  17.  
  18. #define WIDTH    192
  19. #define HEIGHT    99
  20.  
  21. VOID
  22. RefreshFastWindow(WORD Height)
  23. {
  24.     struct Gadget        *Gadget;
  25.     struct NewGadget     NewGadget;
  26.     WORD             TopEdge = Screen -> WBorTop + Screen -> Font -> ta_YSize + 1;
  27.  
  28.     memset(&NewGadget,0,sizeof(struct NewGadget));
  29.  
  30.     if(GadgetList)
  31.     {
  32.         RemoveGList(FastWindow,GadgetList,-1);
  33.  
  34.         SetAPen(FastWindow -> RPort,0);
  35.  
  36.         RectFill(FastWindow -> RPort,FastWindow -> BorderRight,FastWindow -> BorderTop,FastWindow -> Width - (FastWindow -> BorderLeft + 1),FastWindow -> Height - (FastWindow -> BorderBottom + 1));
  37.  
  38.         FreeGadgets(GadgetList);
  39.  
  40.         GadgetList = NULL;
  41.     }
  42.  
  43.     if(Gadget = CreateContext(&GadgetList))
  44.     {
  45.         NewGadget . ng_Width        = 180;
  46.         NewGadget . ng_Height        = Height - (TopEdge + 4 + 8);
  47.         NewGadget . ng_GadgetText    = "";
  48.         NewGadget . ng_GadgetID        = 0;
  49.         NewGadget . ng_LeftEdge        = 6;
  50.         NewGadget . ng_TopEdge        = 1 + TopEdge;
  51.         NewGadget . ng_TextAttr        = &DefaultFont;
  52.         NewGadget . ng_VisualInfo    = VisualInfo;
  53.     
  54.         FastGadget = Gadget = CreateGadget(LISTVIEW_KIND,Gadget,&NewGadget,
  55.             GTLV_Labels,    &FastMacroList,
  56.         TAG_DONE);
  57.     }
  58.  
  59.     if(Gadget)
  60.     {
  61.         AddGList(FastWindow,GadgetList,(UWORD)-1,(UWORD)-1,NULL);
  62.         RefreshGList(GadgetList,FastWindow,NULL,(UWORD)-1);
  63.         GT_RefreshWindow(FastWindow,NULL);
  64.     }
  65.     else
  66.     {
  67.         FreeGadgets(GadgetList);
  68.  
  69.         GadgetList = NULL;
  70.     }
  71. }
  72.  
  73. VOID
  74. CloseFastWindow()
  75. {
  76.     if(FastWindow)
  77.     {
  78.         Left    = FastWindow -> LeftEdge;
  79.         Top    = FastWindow -> TopEdge;
  80.         Height    = FastWindow -> Height;
  81.  
  82.         ClearMenuStrip(FastWindow);
  83.         CloseWindowSafely(FastWindow);
  84.  
  85.         FastWindow = NULL;
  86.     }
  87.  
  88.     if(GadgetList)
  89.     {
  90.         FreeGadgets(GadgetList);
  91.  
  92.         GadgetList = NULL;
  93.     }
  94. }
  95.  
  96. BYTE
  97. OpenFastWindow()
  98. {
  99.     if(Height == -1)
  100.         Height = HEIGHT;
  101.  
  102.     if(Left == -1)
  103.         Left = Screen -> Width - WIDTH;
  104.  
  105.     if(Top == -1)
  106.         Top = Screen -> WBorTop + Screen -> Font -> ta_YSize + 1;
  107.  
  108.     if(Top + Height > Screen -> Height)
  109.     {
  110.         if(Top >= Screen -> Height - (HEIGHT - 56))
  111.             Top = Screen -> Height - (HEIGHT - 56);
  112.  
  113.         while(Top + Height > Screen -> Height)
  114.             Height--;
  115.     }
  116.  
  117.     if(Dims . Left == -1)
  118.     {
  119.         Dims . Left    = 0;
  120.         Dims . Top    = 0;
  121.         Dims . Width    = WIDTH;
  122.         Dims . Height    = Screen -> WBorTop + Screen -> Font -> ta_YSize + 1;
  123.     }
  124.  
  125.     if(FastWindow = OpenWindowTags(NULL,
  126.         WA_Width,    WIDTH,
  127.         WA_Height,    Height,
  128.  
  129.         WA_Left,    Left,
  130.         WA_Top,        Top,
  131.  
  132.         WA_DragBar,    TRUE,
  133.         WA_DepthGadget,    TRUE,
  134.         WA_CloseGadget,    TRUE,
  135.         WA_RMBTrap,    TRUE,
  136.         WA_Zoom,    &Dims,
  137.  
  138.         WA_SizeGadget,    TRUE,
  139.         WA_SizeBBottom,    TRUE,
  140.  
  141.         WA_MinWidth,    WIDTH,
  142.         WA_MaxWidth,    WIDTH,
  143.  
  144.         WA_MinHeight,    HEIGHT - 56,
  145.         WA_MaxHeight,    ~0,
  146.  
  147.         WA_Title,    LocaleString(MSG_FASTMACROS_FAST_MACROS_TXT),
  148.  
  149.         WA_CustomScreen,Screen,
  150.     TAG_DONE))
  151.     {
  152.         FastWindow -> UserPort = Window -> UserPort;
  153.  
  154.         ModifyIDCMP(FastWindow,Window -> IDCMPFlags);
  155.  
  156.         SetMenuStrip(FastWindow,Menu);
  157.  
  158.         FastWindow -> Flags &= ~WFLG_RMBTRAP;
  159.  
  160.         RefreshFastWindow(Height);
  161.  
  162.         return(TRUE);
  163.     }
  164.  
  165.     return(FALSE);
  166. }
  167.  
  168. struct MacroNode *
  169. NewFastMacro(UBYTE *Macro,UBYTE *Code)
  170. {
  171.     struct MacroNode *Node;
  172.  
  173.     if(Node = (struct MacroNode *)AllocVec(sizeof(struct MacroNode) + 21 + 257,MEMF_ANY|MEMF_CLEAR))
  174.     {
  175.         Node -> mn_Macro    = (UBYTE *)(Node + 1);
  176.         Node -> mn_Code        = &Node -> mn_Macro[21];
  177.  
  178.         strcpy(Node -> mn_Macro,Macro);
  179.         strcpy(Node -> mn_Code ,Code);
  180.  
  181.         return(Node);
  182.     }
  183.  
  184.     return(NULL);
  185. }
  186.  
  187. VOID
  188. RemFastMacro(struct MacroNode *Node)
  189. {
  190.     Remove((struct Node *)Node);
  191.  
  192.     FreeVec(Node);
  193. }
  194.  
  195. struct MacroNode *
  196. GetFastMacro(LONG Offset)
  197. {
  198.     struct MacroNode    *Node;
  199.     LONG             i;
  200.  
  201.     Node = (struct MacroNode *)FastMacroList . lh_Head;
  202.  
  203.     for(i = 0 ; i < Offset ; i++)
  204.     {
  205.         if(!Node -> mn_Succ -> mn_Succ)
  206.             return(NULL);
  207.  
  208.         Node = Node -> mn_Succ;
  209.     }
  210.  
  211.     return(Node);
  212. }
  213.  
  214. VOID
  215. ClearFastMacroList(struct List *List)
  216. {
  217.     struct Node *Node,*NextNode;
  218.  
  219.     Node = List -> lh_Head;
  220.  
  221.     while(Node -> ln_Succ)
  222.     {
  223.         NextNode = Node -> ln_Succ;
  224.  
  225.         Remove(Node);
  226.  
  227.         FreeVec(Node);
  228.  
  229.         Node = NextNode;
  230.     }
  231. }
  232.  
  233. LONG
  234. GetFastMacroOffset(struct MacroNode *MacroNode)
  235. {
  236.     struct MacroNode    *Node;
  237.     LONG             Offset = 0;
  238.  
  239.     Node = (struct MacroNode *)FastMacroList . lh_Head;
  240.  
  241.     while(Node -> mn_Succ)
  242.     {
  243.         if(Node == MacroNode)
  244.             return(Offset);
  245.  
  246.         Offset++;
  247.  
  248.         Node = Node -> mn_Succ;
  249.     }
  250.  
  251.     return(~0);
  252. }
  253.  
  254. BYTE
  255. SaveFastMacros(UBYTE *Name)
  256. {
  257.     struct IFFHandle    *Handle;
  258.     BYTE             Success = FALSE;
  259.  
  260.     if(Handle = (struct IFFHandle *)AllocIFF())
  261.     {
  262.         if(Handle -> iff_Stream = Open(Name,MODE_NEWFILE))
  263.         {
  264.             InitIFFasDOS(Handle);
  265.  
  266.             if(!OpenIFF(Handle,IFFF_WRITE))
  267.             {
  268.                 if(!PushChunk(Handle,'TERM',ID_CAT,IFFSIZE_UNKNOWN))
  269.                 {
  270.                     if(!PushChunk(Handle,'TERM',ID_FORM,IFFSIZE_UNKNOWN))
  271.                     {
  272.                         if(!PushChunk(Handle,0,'VERS',IFFSIZE_UNKNOWN))
  273.                         {
  274.                             struct TermInfo TermInfo;
  275.  
  276.                             TermInfo . Version    = TermVersion;
  277.                             TermInfo . Revision    = TermRevision;
  278.  
  279.                             if(WriteChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  280.                             {
  281.                                 if(PopChunk(Handle))
  282.                                     Success = FALSE;
  283.                                 else
  284.                                 {
  285.                                     if(!PushChunk(Handle,0,'WIND',sizeof(struct IBox)))
  286.                                     {
  287.                                         struct IBox SizeBox;
  288.  
  289.                                         if(FastWindow)
  290.                                         {
  291.                                             Left    = FastWindow -> LeftEdge;
  292.                                             Top    = FastWindow -> TopEdge;
  293.                                             Height    = FastWindow -> Height;
  294.                                         }
  295.  
  296.                                         if(Height == -1)
  297.                                             SizeBox . Height = HEIGHT;
  298.                                         else
  299.                                             SizeBox . Height = Height;
  300.  
  301.                                         if(Left == -1)
  302.                                             SizeBox . Left = Screen -> Width - WIDTH;
  303.                                         else
  304.                                             SizeBox . Left = Left;
  305.  
  306.                                         if(Top == -1)
  307.                                             SizeBox . Top = Screen -> WBorTop + Screen -> Font -> ta_YSize + 1;
  308.                                         else
  309.                                             SizeBox . Top = Top;
  310.  
  311.                                         if(WriteChunkBytes(Handle,&SizeBox,sizeof(struct IBox)) == sizeof(struct IBox))
  312.                                         {
  313.                                             if(PopChunk(Handle))
  314.                                                 Success = FALSE;
  315.                                             else
  316.                                             {
  317.                                                 struct MacroNode *Node;
  318.  
  319.                                                 Node = (struct MacroNode *)FastMacroList . lh_Head;
  320.  
  321.                                                 while(Node -> mn_Succ)
  322.                                                 {
  323.                                                     if(!PushChunk(Handle,'TERM',ID_FORM,IFFSIZE_UNKNOWN))
  324.                                                     {
  325.                                                         if(!PushChunk(Handle,0,'FAST',IFFSIZE_UNKNOWN))
  326.                                                         {
  327.                                                             if(WriteChunkBytes(Handle,Node -> mn_Macro,20) != 20)
  328.                                                             {
  329.                                                                 Success = FALSE;
  330.  
  331.                                                                 break;
  332.                                                             }
  333.                                                             else
  334.                                                             {
  335.                                                                 if(WriteChunkBytes(Handle,Node -> mn_Code,256) != 256)
  336.                                                                 {
  337.                                                                     Success = FALSE;
  338.  
  339.                                                                     break;
  340.                                                                 }
  341.                                                                 else
  342.                                                                 {
  343.                                                                     if(PopChunk(Handle))
  344.                                                                     {
  345.                                                                         Success = FALSE;
  346.  
  347.                                                                         break;
  348.                                                                     }
  349.                                                                     else
  350.                                                                         Success = TRUE;
  351.                                                                 }
  352.                                                             }
  353.                                                         }
  354.  
  355.                                                         if(Success)
  356.                                                         {
  357.                                                             if(PopChunk(Handle))
  358.                                                             {
  359.                                                                 Success = FALSE;
  360.  
  361.                                                                 break;
  362.                                                             }
  363.                                                         }
  364.                                                     }
  365.  
  366.                                                     Node = Node -> mn_Succ;
  367.                                                 }
  368.                                             }
  369.                                         }
  370.                                     }
  371.                                 }
  372.                             }
  373.                         }
  374.  
  375.                         if(PopChunk(Handle))
  376.                             Success = FALSE;
  377.                     }
  378.  
  379.                     if(PopChunk(Handle))
  380.                         Success = FALSE;
  381.                 }
  382.  
  383.                 CloseIFF(Handle);
  384.             }
  385.  
  386.             Close(Handle -> iff_Stream);
  387.         }
  388.  
  389.         FreeIFF(Handle);
  390.     }
  391.  
  392.     if(Success)
  393.         SetProtection(Name,FIBF_EXECUTE);
  394.     else
  395.         DeleteFile(Name);
  396.  
  397.     return(Success);
  398. }
  399.  
  400. VOID __regargs
  401. MoveList(struct List *From,struct List *To)
  402. {
  403.     struct Node *Node,*NextNode;
  404.  
  405.     Node = From -> lh_Head;
  406.  
  407.     while(NextNode = Node -> ln_Succ)
  408.     {
  409.         Remove(Node);
  410.  
  411.         AddTail(To,Node);
  412.  
  413.         Node = NextNode;
  414.     }
  415. }
  416.  
  417. BYTE
  418. LoadFastMacros(UBYTE *Name)
  419. {
  420.     STATIC ULONG Stops[6] =
  421.     {
  422.         'TERM','VERS',
  423.         'TERM','FAST',
  424.         'TERM','WIND'
  425.     };
  426.  
  427.     struct List __aligned     NewFastMacroList;
  428.     LONG             NewFastMacroCount = 0;
  429.     struct IFFHandle    *Handle;
  430.     BYTE             Success = FALSE;
  431.     struct MacroNode    *Node;
  432.     struct ContextNode    *Chunk;
  433.     struct IBox         SizeBox;
  434.  
  435.     NewList(&NewFastMacroList);
  436.  
  437.     if(Handle = AllocIFF())
  438.     {
  439.         if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  440.         {
  441.             InitIFFasDOS(Handle);
  442.  
  443.             if(!OpenIFF(Handle,IFFF_READ))
  444.             {
  445.                 if(!StopChunks(Handle,&Stops[0],3))
  446.                 {
  447.                     while(!ParseIFF(Handle,IFFPARSE_SCAN))
  448.                     {
  449.                         Chunk = CurrentChunk(Handle);
  450.  
  451.                         if(Chunk -> cn_ID == 'VERS')
  452.                         {
  453.                             struct TermInfo TermInfo;
  454.  
  455.                             if(ReadChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  456.                             {
  457.                                 if((TermInfo . Version > TermVersion) || (TermInfo . Version == TermVersion && TermInfo . Revision > TermRevision) || (TermInfo . Version == 1 && TermInfo . Revision < 6))
  458.                                     break;
  459.                             }
  460.                             else
  461.                                 break;
  462.                         }
  463.  
  464.                         if(Chunk -> cn_ID == 'WIND')
  465.                         {
  466.                             if(ReadChunkBytes(Handle,&SizeBox,sizeof(struct IBox)) == sizeof(struct IBox))
  467.                             {
  468.                                 Left    = SizeBox . Left;
  469.                                 Top    = SizeBox . Top;
  470.                                 Height    = SizeBox . Height;
  471.                             }
  472.                             else
  473.                                 break;
  474.                         }
  475.  
  476.                         if(Chunk -> cn_ID == 'FAST')
  477.                         {
  478.                             if(Node = NewFastMacro("",""))
  479.                             {
  480.                                 if(ReadChunkBytes(Handle,Node -> mn_Macro,20) == 20)
  481.                                 {
  482.                                     if(ReadChunkBytes(Handle,Node -> mn_Code,256) == 256)
  483.                                     {
  484.                                         AddTail(&NewFastMacroList,(struct Node *)Node);
  485.  
  486.                                         NewFastMacroCount++;
  487.  
  488.                                         Success = TRUE;
  489.                                     }
  490.                                     else
  491.                                         break;
  492.                                 }
  493.                                 else
  494.                                     break;
  495.                             }
  496.                             else
  497.                                 break;
  498.                         }
  499.                     }
  500.  
  501.                     if(Success)
  502.                     {
  503.                         if(NewFastMacroList . lh_Head -> ln_Succ)
  504.                         {
  505.                             ClearFastMacroList(&FastMacroList);
  506.  
  507.                             MoveList(&NewFastMacroList,&FastMacroList);
  508.  
  509.                             FastMacroCount = NewFastMacroCount;
  510.                         }
  511.                     }
  512.                     else
  513.                         ClearFastMacroList(&NewFastMacroList);
  514.                 }
  515.  
  516.                 CloseIFF(Handle);
  517.             }
  518.  
  519.             Close(Handle -> iff_Stream);
  520.         }
  521.  
  522.         FreeIFF(Handle);
  523.     }
  524.  
  525.     return(Success);
  526. }
  527.